{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "xecWenxLyjqY"
      },
      "source": [
        "# Defining Expressiveness for Graph Classification"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9ufjArMmycpW"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "!pip install -q torch-scatter~=2.1.0 torch-sparse~=0.6.16 torch-cluster~=1.6.0 torch-spline-conv~=1.2.1 torch-geometric==2.2.0 -f https://data.pyg.org/whl/torch-{torch.__version__}.html\n",
        "\n",
        "torch.manual_seed(11)\n",
        "torch.cuda.manual_seed(0)\n",
        "torch.cuda.manual_seed_all(0)\n",
        "torch.backends.cudnn.deterministic = True\n",
        "torch.backends.cudnn.benchmark = False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xdj2ss23zf53",
        "outputId": "2d5e9106-8719-4d44-edd2-46f4cb2a0763"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Dataset: PROTEINS(1113)\n",
            "-----------------------\n",
            "Number of graphs: 1113\n",
            "Number of nodes: 20\n",
            "Number of features: 3\n",
            "Number of classes: 2\n"
          ]
        }
      ],
      "source": [
        "from torch_geometric.datasets import TUDataset\n",
        "\n",
        "dataset = TUDataset(root='.', name='PROTEINS').shuffle()\n",
        "\n",
        "# Print information about the dataset\n",
        "print(f'Dataset: {dataset}')\n",
        "print('-----------------------')\n",
        "print(f'Number of graphs: {len(dataset)}')\n",
        "print(f'Number of nodes: {dataset[0].x.shape[0]}')\n",
        "print(f'Number of features: {dataset.num_features}')\n",
        "print(f'Number of classes: {dataset.num_classes}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tTrGjVrgzh3N",
        "outputId": "24894bf2-21b4-4c42-b7a7-961a7f371300"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training set   = 890 graphs\n",
            "Validation set = 111 graphs\n",
            "Test set       = 112 graphs\n",
            "\n",
            "Train loader:\n",
            " - Batch 0: DataBatch(edge_index=[2, 11774], x=[3205, 3], y=[64], batch=[3205], ptr=[65])\n",
            " - Batch 1: DataBatch(edge_index=[2, 7978], x=[2135, 3], y=[64], batch=[2135], ptr=[65])\n",
            " - Batch 2: DataBatch(edge_index=[2, 9382], x=[2511, 3], y=[64], batch=[2511], ptr=[65])\n",
            " - Batch 3: DataBatch(edge_index=[2, 10842], x=[2775, 3], y=[64], batch=[2775], ptr=[65])\n",
            " - Batch 4: DataBatch(edge_index=[2, 9502], x=[2565, 3], y=[64], batch=[2565], ptr=[65])\n",
            " - Batch 5: DataBatch(edge_index=[2, 8484], x=[2345, 3], y=[64], batch=[2345], ptr=[65])\n",
            " - Batch 6: DataBatch(edge_index=[2, 9800], x=[2661, 3], y=[64], batch=[2661], ptr=[65])\n",
            " - Batch 7: DataBatch(edge_index=[2, 9074], x=[2412, 3], y=[64], batch=[2412], ptr=[65])\n",
            " - Batch 8: DataBatch(edge_index=[2, 9502], x=[2622, 3], y=[64], batch=[2622], ptr=[65])\n",
            " - Batch 9: DataBatch(edge_index=[2, 9554], x=[2453, 3], y=[64], batch=[2453], ptr=[65])\n",
            " - Batch 10: DataBatch(edge_index=[2, 8316], x=[2338, 3], y=[64], batch=[2338], ptr=[65])\n",
            " - Batch 11: DataBatch(edge_index=[2, 9698], x=[2753, 3], y=[64], batch=[2753], ptr=[65])\n",
            " - Batch 12: DataBatch(edge_index=[2, 8210], x=[2087, 3], y=[64], batch=[2087], ptr=[65])\n",
            " - Batch 13: DataBatch(edge_index=[2, 9060], x=[2344, 3], y=[58], batch=[2344], ptr=[59])\n",
            "\n",
            "Validation loader:\n",
            " - Batch 0: DataBatch(edge_index=[2, 8824], x=[2410, 3], y=[64], batch=[2410], ptr=[65])\n",
            " - Batch 1: DataBatch(edge_index=[2, 7946], x=[2058, 3], y=[47], batch=[2058], ptr=[48])\n",
            "\n",
            "Test loader:\n",
            " - Batch 0: DataBatch(edge_index=[2, 8438], x=[2285, 3], y=[64], batch=[2285], ptr=[65])\n",
            " - Batch 1: DataBatch(edge_index=[2, 5704], x=[1512, 3], y=[48], batch=[1512], ptr=[49])\n"
          ]
        }
      ],
      "source": [
        "from torch_geometric.loader import DataLoader\n",
        "\n",
        "# Create training, validation, and test sets\n",
        "train_dataset = dataset[:int(len(dataset)*0.8)]\n",
        "val_dataset   = dataset[int(len(dataset)*0.8):int(len(dataset)*0.9)]\n",
        "test_dataset  = dataset[int(len(dataset)*0.9):]\n",
        "\n",
        "print(f'Training set   = {len(train_dataset)} graphs')\n",
        "print(f'Validation set = {len(val_dataset)} graphs')\n",
        "print(f'Test set       = {len(test_dataset)} graphs')\n",
        "\n",
        "# Create mini-batches\n",
        "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
        "val_loader   = DataLoader(val_dataset, batch_size=64, shuffle=True)\n",
        "test_loader  = DataLoader(test_dataset, batch_size=64, shuffle=True)\n",
        "\n",
        "print('\\nTrain loader:')\n",
        "for i, batch in enumerate(train_loader):\n",
        "    print(f' - Batch {i}: {batch}')\n",
        "\n",
        "print('\\nValidation loader:')\n",
        "for i, batch in enumerate(val_loader):\n",
        "    print(f' - Batch {i}: {batch}')\n",
        "\n",
        "print('\\nTest loader:')\n",
        "for i, batch in enumerate(test_loader):\n",
        "    print(f' - Batch {i}: {batch}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "hIQe2XRGzk8t"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "torch.manual_seed(0)\n",
        "import torch.nn.functional as F\n",
        "from torch.nn import Linear, Sequential, BatchNorm1d, ReLU, Dropout\n",
        "from torch_geometric.nn import GCNConv, GINConv\n",
        "from torch_geometric.nn import global_mean_pool, global_add_pool\n",
        "\n",
        "\n",
        "class GCN(torch.nn.Module):\n",
        "    \"\"\"GCN\"\"\"\n",
        "    def __init__(self, dim_h):\n",
        "        super(GCN, self).__init__()\n",
        "        self.conv1 = GCNConv(dataset.num_node_features, dim_h)\n",
        "        self.conv2 = GCNConv(dim_h, dim_h)\n",
        "        self.conv3 = GCNConv(dim_h, dim_h)\n",
        "        self.lin = Linear(dim_h, dataset.num_classes)\n",
        "\n",
        "    def forward(self, x, edge_index, batch):\n",
        "        # Node embeddings \n",
        "        h = self.conv1(x, edge_index)\n",
        "        h = h.relu()\n",
        "        h = self.conv2(h, edge_index)\n",
        "        h = h.relu()\n",
        "        h = self.conv3(h, edge_index)\n",
        "\n",
        "        # Graph-level readout\n",
        "        hG = global_mean_pool(h, batch)\n",
        "\n",
        "        # Classifier\n",
        "        h = F.dropout(hG, p=0.5, training=self.training)\n",
        "        h = self.lin(h)\n",
        "        \n",
        "        return F.log_softmax(h, dim=1)\n",
        "\n",
        "class GIN(torch.nn.Module):\n",
        "    \"\"\"GIN\"\"\"\n",
        "    def __init__(self, dim_h):\n",
        "        super(GIN, self).__init__()\n",
        "        self.conv1 = GINConv(\n",
        "            Sequential(Linear(dataset.num_node_features, dim_h),\n",
        "                       BatchNorm1d(dim_h), ReLU(),\n",
        "                       Linear(dim_h, dim_h), ReLU()))\n",
        "        self.conv2 = GINConv(\n",
        "            Sequential(Linear(dim_h, dim_h), BatchNorm1d(dim_h), ReLU(),\n",
        "                       Linear(dim_h, dim_h), ReLU()))\n",
        "        self.conv3 = GINConv(\n",
        "            Sequential(Linear(dim_h, dim_h), BatchNorm1d(dim_h), ReLU(),\n",
        "                       Linear(dim_h, dim_h), ReLU()))\n",
        "        self.lin1 = Linear(dim_h*3, dim_h*3)\n",
        "        self.lin2 = Linear(dim_h*3, dataset.num_classes)\n",
        "\n",
        "    def forward(self, x, edge_index, batch):\n",
        "        # Node embeddings \n",
        "        h1 = self.conv1(x, edge_index)\n",
        "        h2 = self.conv2(h1, edge_index)\n",
        "        h3 = self.conv3(h2, edge_index)\n",
        "\n",
        "        # Graph-level readout\n",
        "        h1 = global_add_pool(h1, batch)\n",
        "        h2 = global_add_pool(h2, batch)\n",
        "        h3 = global_add_pool(h3, batch)\n",
        "\n",
        "        # Concatenate graph embeddings\n",
        "        h = torch.cat((h1, h2, h3), dim=1)\n",
        "\n",
        "        # Classifier\n",
        "        h = self.lin1(h)\n",
        "        h = h.relu()\n",
        "        h = F.dropout(h, p=0.5, training=self.training)\n",
        "        h = self.lin2(h)\n",
        "        \n",
        "        return F.log_softmax(h, dim=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gm59vGxKznxp",
        "outputId": "86888f83-7f8c-4eff-ac64-6e101732c456"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch   0 | Train Loss: 0.67 | Train Acc: 59.21% | Val Loss: 0.66 | Val Acc: 60.26%\n",
            "Epoch  20 | Train Loss: 0.60 | Train Acc: 71.38% | Val Loss: 0.60 | Val Acc: 69.76%\n",
            "Epoch  40 | Train Loss: 0.60 | Train Acc: 70.32% | Val Loss: 0.60 | Val Acc: 70.98%\n",
            "Epoch  60 | Train Loss: 0.59 | Train Acc: 70.81% | Val Loss: 0.60 | Val Acc: 70.55%\n",
            "Epoch  80 | Train Loss: 0.60 | Train Acc: 70.56% | Val Loss: 0.59 | Val Acc: 72.61%\n",
            "Epoch 100 | Train Loss: 0.59 | Train Acc: 71.33% | Val Loss: 0.60 | Val Acc: 71.39%\n",
            "Test Loss: 0.58 | Test Acc: 73.70%\n",
            "\n",
            "Epoch   0 | Train Loss: 1.33 | Train Acc: 58.04% | Val Loss: 0.70 | Val Acc: 59.97%\n",
            "Epoch  20 | Train Loss: 0.54 | Train Acc: 74.50% | Val Loss: 0.55 | Val Acc: 76.86%\n",
            "Epoch  40 | Train Loss: 0.50 | Train Acc: 76.28% | Val Loss: 0.56 | Val Acc: 74.73%\n",
            "Epoch  60 | Train Loss: 0.50 | Train Acc: 76.77% | Val Loss: 0.54 | Val Acc: 72.04%\n",
            "Epoch  80 | Train Loss: 0.49 | Train Acc: 76.95% | Val Loss: 0.57 | Val Acc: 73.67%\n",
            "Epoch 100 | Train Loss: 0.50 | Train Acc: 76.04% | Val Loss: 0.53 | Val Acc: 69.55%\n",
            "Test Loss: 0.44 | Test Acc: 81.77%\n"
          ]
        }
      ],
      "source": [
        "def train(model, loader):\n",
        "    criterion = torch.nn.CrossEntropyLoss()\n",
        "    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
        "    epochs = 100\n",
        "\n",
        "    model.train()\n",
        "    for epoch in range(epochs+1):\n",
        "        total_loss = 0\n",
        "        acc = 0\n",
        "        val_loss = 0\n",
        "        val_acc = 0\n",
        "\n",
        "        # Train on batches\n",
        "        for data in loader:\n",
        "            optimizer.zero_grad()\n",
        "            out = model(data.x, data.edge_index, data.batch)\n",
        "            loss = criterion(out, data.y)\n",
        "            total_loss += loss / len(loader)\n",
        "            acc += accuracy(out.argmax(dim=1), data.y) / len(loader)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            # Validation\n",
        "            val_loss, val_acc = test(model, val_loader)\n",
        "\n",
        "        # Print metrics every 20 epochs\n",
        "        if(epoch % 20 == 0):\n",
        "            print(f'Epoch {epoch:>3} | Train Loss: {total_loss:.2f} | Train Acc: {acc*100:>5.2f}% | Val Loss: {val_loss:.2f} | Val Acc: {val_acc*100:.2f}%')\n",
        "            \n",
        "    return model\n",
        "\n",
        "@torch.no_grad()\n",
        "def test(model, loader):\n",
        "    criterion = torch.nn.CrossEntropyLoss()\n",
        "    model.eval()\n",
        "    loss = 0\n",
        "    acc = 0\n",
        "\n",
        "    for data in loader:\n",
        "        out = model(data.x, data.edge_index, data.batch)\n",
        "        loss += criterion(out, data.y) / len(loader)\n",
        "        acc += accuracy(out.argmax(dim=1), data.y) / len(loader)\n",
        "\n",
        "    return loss, acc\n",
        "\n",
        "def accuracy(pred_y, y):\n",
        "    \"\"\"Calculate accuracy.\"\"\"\n",
        "    return ((pred_y == y).sum() / len(y)).item()\n",
        "\n",
        "gcn = GCN(dim_h=32)\n",
        "gcn = train(gcn, train_loader)\n",
        "test_loss, test_acc = test(gcn, test_loader)\n",
        "print(f'Test Loss: {test_loss:.2f} | Test Acc: {test_acc*100:.2f}%')\n",
        "print()\n",
        "\n",
        "gin = GIN(dim_h=32)\n",
        "gin = train(gin, train_loader)\n",
        "test_loss, test_acc = test(gin, test_loader)\n",
        "print(f'Test Loss: {test_loss:.2f} | Test Acc: {test_acc*100:.2f}%')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 882
        },
        "id": "Rl2fwB2jzsPl",
        "outputId": "661d811b-14a1-4f67-ba78-d644b883655c"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 16 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "from torch_geometric.utils import to_networkx\n",
        "\n",
        "fig, ax = plt.subplots(4, 4)\n",
        "fig.suptitle('GCN - Graph classification')\n",
        "\n",
        "for i, data in enumerate(dataset[-16:]):\n",
        "    # Calculate color (green if correct, red otherwise)\n",
        "    out = gcn(data.x, data.edge_index, data.batch)\n",
        "    color = \"green\" if out.argmax(dim=1) == data.y else \"red\"\n",
        "\n",
        "    # Plot graph\n",
        "    ix = np.unravel_index(i, ax.shape)\n",
        "    ax[ix].axis('off')\n",
        "    G = to_networkx(dataset[i], to_undirected=True)\n",
        "    nx.draw_networkx(G,\n",
        "                    pos=nx.spring_layout(G, seed=0),\n",
        "                    with_labels=False,\n",
        "                    node_size=10,\n",
        "                    node_color=color,\n",
        "                    width=0.8,\n",
        "                    ax=ax[ix]\n",
        "                    )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 882
        },
        "id": "BhNQMkbZzttF",
        "outputId": "4c6fff0c-73a3-4f9f-b701-fae0b0f995f0"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 16 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "fig, ax = plt.subplots(4, 4)\n",
        "fig.suptitle('GIN - Graph classification')\n",
        "\n",
        "for i, data in enumerate(dataset[-16:]):\n",
        "    # Calculate color (green if correct, red otherwise)\n",
        "    out = gin(data.x, data.edge_index, data.batch)\n",
        "    color = \"green\" if out.argmax(dim=1) == data.y else \"red\"\n",
        "\n",
        "    # Plot graph\n",
        "    ix = np.unravel_index(i, ax.shape)\n",
        "    ax[ix].axis('off')\n",
        "    G = to_networkx(dataset[i], to_undirected=True)\n",
        "    nx.draw_networkx(G,\n",
        "                    pos=nx.spring_layout(G, seed=0),\n",
        "                    with_labels=False,\n",
        "                    node_size=10,\n",
        "                    node_color=color,\n",
        "                    width=0.8,\n",
        "                    ax=ax[ix]\n",
        "                    )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "oNrv64rYzvVJ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "GCN accuracy:     72.14%\n",
            "GIN accuracy:     80.99%\n",
            "GCN+GIN accuracy: 81.25%\n"
          ]
        }
      ],
      "source": [
        "gcn.eval()\n",
        "gin.eval()\n",
        "acc_gcn = 0\n",
        "acc_gin = 0\n",
        "acc_ens = 0\n",
        "\n",
        "for data in test_loader:\n",
        "    # Get classifications\n",
        "    out_gcn = gcn(data.x, data.edge_index, data.batch)\n",
        "    out_gin = gin(data.x, data.edge_index, data.batch)\n",
        "    out_ens = (out_gcn + out_gin)/2\n",
        "\n",
        "    # Calculate accuracy scores\n",
        "    acc_gcn += accuracy(out_gcn.argmax(dim=1), data.y) / len(test_loader)\n",
        "    acc_gin += accuracy(out_gin.argmax(dim=1), data.y) / len(test_loader)\n",
        "    acc_ens += accuracy(out_ens.argmax(dim=1), data.y) / len(test_loader)\n",
        "\n",
        "# Print results\n",
        "print(f'GCN accuracy:     {acc_gcn*100:.2f}%')\n",
        "print(f'GIN accuracy:     {acc_gin*100:.2f}%')\n",
        "print(f'GCN+GIN accuracy: {acc_ens*100:.2f}%')"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "book",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.15 (default, Nov 24 2022, 14:38:14) [MSC v.1916 64 bit (AMD64)]"
    },
    "vscode": {
      "interpreter": {
        "hash": "3556630122da5213751af4465d61fcf5a52cd22515d400aee51118aaa1721248"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
